home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ext2_200.zip / EXT2_SRC.ZIP / 32BITS / EXT2-OS2 / FILES.C < prev    next >
C/C++ Source or Header  |  1996-09-22  |  10KB  |  249 lines
  1. #ifdef __IBMC__
  2. #pragma strings(readonly)
  3. #endif
  4. //
  5. // $Header: D:/32bits/ext2-os2/RCS/files.c,v 1.1 1996/09/22 23:13:48 Willm Exp Willm $
  6. //
  7.  
  8. // Linux ext2 file system driver for OS/2 2.x and WARP - Allows OS/2 to     
  9. // access your Linux ext2fs partitions as normal drive letters.
  10. // Copyright (C) 1995, 1996 Matthieu WILLM 
  11. //
  12. // This program is free software; you can redistribute it and/or modify
  13. // it under the terms of the GNU General Public License as published by
  14. // the Free Software Foundation; either version 2 of the License, or
  15. // (at your option) any later version.
  16. //
  17. // This program is distributed in the hope that it will be useful,
  18. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. // GNU General Public License for more details.
  21. //
  22. // You should have received a copy of the GNU General Public License
  23. // along with this program; if not, write to the Free Software
  24. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  
  26.  
  27.  
  28. #define INCL_DOSERRORS
  29. #define INCL_NOPMAPI
  30. #include <os2.h>        // From the "Developer Connection Device Driver Kit" version 2.0
  31.  
  32. #include <string.h>
  33.  
  34. #include <os2/types.h>
  35. #include <os2/StackToFlat.h>
  36. #include <os2/DevHlp32.h>
  37. #include <os2/os2proto.h>
  38. #include <os2/errors.h>
  39.  
  40. #include <linux/fs.h>
  41. #include <linux/fs_proto.h>
  42. #include <linux/ext2_proto.h>
  43. #include <os2/log.h>         /* Prototypes des fonctions de log.c                      */
  44. #include <os2/files.h>       /* Prototypes des fonctions de files.c                    */
  45. #include <os2/fnmatch.h>
  46.  
  47. //
  48. // These routines will be eventually rewritten and splitted between ext2/namei.c
  49. // (namei()), vfs/namei.c (dir_namei, open_namei, ....) and vfs/open.c (do_open ...)
  50. //
  51.  
  52. struct file *_open_by_inode(struct super_block * p_volume, UINT32 ino_no, UINT32 openmode)
  53. {
  54.     struct file   *      p_file;
  55.     int           rc;
  56.  
  57. #ifdef FS_TRACE
  58.     kernel_printf("open_by_inode( %lu )", ino_no);
  59. #endif
  60.     /*******************************************************************/
  61.     /*** Allocates a file descriptor                                 ***/
  62.     /*******************************************************************/
  63.     if ((p_file = get_empty_filp()) == 0) {
  64.         fs_err(FUNC_OPEN_BY_INODE, FUNC_ALLOC_HFILE, 0, FILE_FILES_C, __LINE__);
  65.         return 0;
  66.     }
  67.     /*******************************************************************/
  68.  
  69.     /*******************************************************************/
  70.     /*** Gets the v-inode (if already exists) or allocates a new one ***/
  71.     /*******************************************************************/
  72.     if ((p_file->f_inode = iget(p_volume, ino_no)) == NULL) {
  73.         fs_err(FUNC_OPEN_BY_INODE, FUNC_GET_VINODE, rc, FILE_FILES_C, __LINE__);
  74.         put_filp(p_file);
  75.         return 0;
  76.     }
  77.     /*******************************************************************/
  78.  
  79.  
  80.     p_file->f_pos            = 0;
  81.     p_file->f_mode           = openmode;
  82.     if (p_file->f_inode->i_op)
  83.         p_file->f_op = p_file->f_inode->i_op->default_file_ops;
  84.  
  85.     return p_file;
  86. }
  87.  
  88. int vfs_close(struct file *f)
  89. {
  90.     int           rc;
  91.  
  92. #ifdef FS_TRACE
  93.     kernel_printf("close( %lu )", f->f_inode->i_ino);
  94. #endif
  95.  
  96.     if (f->f_inode)
  97.         iput(f->f_inode);
  98.  
  99.     if ((rc = put_filp(f)) != NO_ERROR) {
  100.         fs_err(FUNC_CLOSE, FUNC_FREE_HFILE, rc, FILE_FILES_C, __LINE__);
  101.         return rc;
  102.     }
  103.  
  104.     return NO_ERROR;
  105. }
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112. struct file *_open_by_name(struct super_block * p_volume, pchar pName, UINT32 openmode)
  113. {
  114.     char        *left;
  115.     char        *right;
  116.     char        *pNom;
  117.     int fn_flag;
  118.     char        *pTmp, *pTmpUpper1, *pTmpUpper2;
  119.     struct file    *    p_file;
  120.     int          ok;
  121.     int          Fin;
  122.     int          FinPath;
  123.     UINT32       ino_no;
  124.     struct dirent          Dir;
  125.     int          rc;
  126.  
  127. #ifdef FS_TRACE
  128.     kernel_printf("open_by_name( %s )", pName);
  129. #endif
  130.     /*******************************************************************/
  131.     /*** We allocate a working buffer                                ***/
  132.     /*******************************************************************/
  133. //    if ((pNom = G_malloc(3 * CCHMAXPATH)) == 0) {
  134. //        fs_err(FUNC_OPEN_BY_NAME, FUNC_G_malloc, rc, FILE_FILES_C, __LINE__);
  135. //        return 0;
  136. //    } /* end if */
  137.     if ((rc = DevHlp32_VMAlloc(3 * CCHMAXPATH, VMDHA_NOPHYSADDR, VMDHA_SWAP, __StackToFlat(&pNom))) != NO_ERROR) {
  138.         fs_err(FUNC_OPEN_BY_NAME, FUNC_G_malloc, rc, FILE_FILES_C, __LINE__);
  139.         return 0;
  140.     }
  141.     memset(pNom, '\0', CCHMAXPATH);
  142.     pTmpUpper1 = pNom + CCHMAXPATH;
  143.     pTmpUpper2 = pTmpUpper1 + CCHMAXPATH;
  144.     /*******************************************************************/
  145.  
  146.     pTmp = DecoupePath(pName, pNom);
  147.     /*******************************************************************/
  148.     /*** If it is the root directory we've finished                  ***/
  149.     /*******************************************************************/
  150.     if (pTmp == 0) {
  151.         /*******************************************************************/
  152.        /*** Frees the working buffer                                    ***/
  153.         /*******************************************************************/
  154.         if ((rc = DevHlp32_VMFree(pNom)) != NO_ERROR) {
  155.             fs_err(FUNC_OPEN_BY_NAME, FUNC_G_free, rc, FILE_FILES_C, __LINE__);
  156.             return 0;
  157.         } /* end if */
  158.         /*******************************************************************/
  159.         return _open_by_inode(p_volume, EXT2_ROOT_INO, openmode);
  160.     } /* end if */
  161.     /*******************************************************************/
  162.  
  163.     /*******************************************************************/
  164.     /*** We loop on the path components                              ***/
  165.     /*******************************************************************/
  166.     ino_no  = EXT2_ROOT_INO;
  167.     FinPath = 0;
  168.     while (FinPath == 0) {
  169.         /*******************************************************************/
  170.         /*** Opens the "." file of the directory                         ***/
  171.         /*******************************************************************/
  172.         if ((p_file = _open_by_inode(p_volume, ino_no, OPENMODE_READONLY)) == 0) {
  173.             fs_err(FUNC_OPEN_BY_NAME, FUNC_OPEN_BY_INODE, 0, FILE_FILES_C, __LINE__);
  174.             if ((rc = DevHlp32_VMFree(pNom)) != NO_ERROR) {
  175.                 fs_err(FUNC_OPEN_BY_NAME, FUNC_G_free, rc, FILE_FILES_C, __LINE__);
  176.                 return 0;
  177.             } /* end if */
  178.             return 0;
  179.         } /* end if */
  180.         /*******************************************************************/
  181.  
  182.             ok = 0;
  183.             Fin = 0;
  184.             /*** Lookup inside the "." file of the parent directory ***/
  185.             while (Fin == 0) {
  186.                 if (VFS_readdir(p_file, __StackToFlat(&Dir)) != 0) {
  187.                     Fin = 1;
  188.                 } else {
  189.                     /*
  190.                      * We do a case insensitive comparaison if needed
  191.                      */
  192.                     if (openmode & OPENMODE_DOSBOX) {
  193. //                        FSH_UPPERCASE(pNom, CCHMAXPATH, pTmpUpper1);
  194. //                        left  = pTmpUpper1;
  195. //                        FSH_UPPERCASE(Dir.d_name, CCHMAXPATH, pTmpUpper2);
  196. //                        right = pTmpUpper2;
  197.                   fn_flag = _FNM_OS2 | _FNM_IGNORECASE;
  198.                     } else {
  199. //                        left  = pNom;
  200. //                        right = Dir.d_name;
  201.             fn_flag = _FNM_OS2;
  202.                     }
  203. //                    if (strcmp(left, right) == 0) {
  204.                        if (fnmatch(pNom, __StackToFlat(Dir.d_name), fn_flag) == 0) {
  205.                         Fin = 1;
  206.                         ok  = 1;
  207.                     } /* end if */
  208.                 } /* end if */
  209.             } /* end while */
  210.             /*** si pas trouvé on retourne 0 ***/
  211.             if (ok == 0) {
  212.                 if ((rc = vfs_close(p_file)) != NO_ERROR) {
  213.                     fs_err(FUNC_OPEN_BY_NAME, FUNC_CLOSE, rc, FILE_FILES_C, __LINE__);
  214.                     return 0; /*** FSH_INTERR() ***/
  215.                 } /* end if */
  216.                if ((rc = DevHlp32_VMFree(pNom)) != NO_ERROR) {
  217.                    fs_err(FUNC_OPEN_BY_NAME, FUNC_G_free, rc, FILE_FILES_C, __LINE__);
  218.                    return 0;
  219.                } /* end if */
  220. //               kernel_printf("open_by_name() ok = 0 - pTmp = %s - pName = %s - pNom = %s", pTmp, pName, pNom);
  221.                return 0;
  222.             } /* end if */
  223.             /*** If found we go down a level ***/
  224.             ino_no = Dir.d_ino;
  225.             if ((rc = vfs_close(p_file)) != NO_ERROR) {
  226.                 fs_err(FUNC_OPEN_BY_NAME, FUNC_CLOSE, rc, FILE_FILES_C, __LINE__);
  227.                 return 0; /*** FSH_INTERR() ***/
  228.             } /* end if */
  229.  
  230.         if ((pTmp = DecoupePath(pTmp, pNom)) == 0) {
  231.             FinPath = 1;
  232.         } /* end if */
  233.  
  234.     } /* end while */
  235.     /*******************************************************************/
  236.  
  237.     /*******************************************************************/
  238.     /*** Frees the working buffer.                                   ***/
  239.     /*******************************************************************/
  240.     if ((rc = DevHlp32_VMFree(pNom)) != NO_ERROR) {
  241.         fs_err(FUNC_OPEN_BY_NAME, FUNC_G_free, rc, FILE_FILES_C, __LINE__);
  242.         return 0;
  243.     } /* end if */
  244.     /*******************************************************************/
  245.  
  246.     return _open_by_inode(p_volume, ino_no, openmode);
  247. }
  248.  
  249.